



#include"stl_print.h"
#include"stl_converter.h"

//#include"stl_type.h"


/////////////////////////////////////////////////////////////////////////////////////

#define is_digit(c)	((c) >= '0' && (c) <= '9')

///// <summary>
///// 字符串指针*s跳过数字，并返回整数的数字。
///// 字符串*s的开头第一个字符是数字串。
///// 例:
///// char ch[]="123hello ";
///// char *str=ch;
///// int num = skip_atoi(&str);
///// 则:num=123，str[0]指向‘h’。
///// </summary>
///// <param name="s">指向字符串的指针的地址。</param>
///// <returns>提取出来的数字</returns>
//static int skip_atoi(const char** s)
//{
//	int i = 0;
//	while (is_digit(**s)) {
//		i = i * 10 + **s - '0';
//		(*s)++;
//	}
//	return i;
//}




//#include<stdarg.h>
/*
 <stdarg.h>头文件的宏定义解析:

#define _INTSIZEOF(n)   ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
//这里参数是4字节sizeof(int)对齐。_INTSIZEOF(n)就是将sizeof(n)补齐到4的倍数。

typedef char* va_list;    //va_list是一个字符串的指针类型。

#define va_start(ap, v) ((void)(ap = (va_list)(v) + _INTSIZEOF(v)))
//x86平台地址从高到低分配内存。栈顶是高地址，参数v是函数的第一个形参，在栈底，低地址。这里先让ap指向下一个参数。

#define va_arg(ap, t)   (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
//取出当前ap指针所指的值，并使ap指向下一个参数。
ap+=sizeof(t类型)，让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)的t类型指针，这是第一个可变参数在堆栈里的地址。
然后用取得这个地址的内容。

#define va_end(ap)      ((void)(ap = (va_list)0))    //让ap指针指向0.这一句放到函数末尾可有可无。为什么要调用这句？清理痕迹防黑客吗？

	//C语言中，函数的参数是从右边到左进栈的，所以字符串fmt是栈底的位置。
	//根据栈底的位置可以计算出函数里有多少个形参。
	//不同底层架构的编译器，参数对齐的方式，栈生长方式可能不一样，因此最好直接调用<stdarg.h>的宏定义，不要自己去定义。
	//自己定义最好先测试一下。

	下面补充一个重点:

函数定义的时候，可变长参数(…)不能放在形参的第一个。必须有一个参数来使得va_start()来定位可变长参数(…)的位置。类型基本随意。
然后，用va_list()来创建参数列表。并且用va_start()来初始化列表为传入的可变长参数。
然后，通过用va_arg()函数来依次读取参数列表中的参数。这里va_arg(ap,type)中，ap指参数列表，type指转换类型。
注意！注意！注意！
type绝对不能为以下类型:

——char、signed char、unsigned char
——short、unsigned short
——signed short、short int、signed short int、unsigned short int
——float
一个float坑了我半个小时！血的教训啊！  用double替换float即可。（不知道为什么）
最后，不要忘记用va_end()来释放参数列表。
*/




#define _INTSIZEOF(n)   ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
//这里参数是4字节sizeof(int)对齐。_INTSIZEOF(n)就是将sizeof(n)补齐到4的倍数。

typedef char* va_list;    //va_list是一个字符串的指针类型。

#define va_start(ap, v) ((void)(ap = (va_list)(v) + _INTSIZEOF(v)))
//x86平台地址从高到低分配内存。栈顶是高地址，参数v是函数的第一个形参，在栈底，低地址。这里先让ap指向下一个参数。

#define va_arg(ap, t)   (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
//取出当前ap指针所指的值，并使ap指向下一个参数。
//ap+=sizeof(t类型)，让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)的t类型指针，这是第一个可变参数在堆栈里的地址。
//然后用取得这个地址的内容。

#define va_end(ap)      ((void)(ap = (va_list)0))    //让ap指针指向0.这一句放到函数末尾可有可无。为什么要调用这句？清理痕迹防黑客吗？

	//C语言中，函数的参数是从右边到左进栈的，所以字符串fmt是栈底的位置。
	//根据栈底的位置可以计算出函数里有多少个形参。
	//不同底层架构的编译器，参数对齐的方式，栈生长方式可能不一样，因此最好直接调用<stdarg.h>的宏定义，不要自己去定义。
	//自己定义最好先测试一下。



int printf_va_list(char* str, const char* fmt, va_list ap)
{
	//va_list ap;
	int str_len = 0; //转换的字符串的长度
	int fmt_len = 0; //格式的宽度
	int fmt_len2 = 0; //格式的宽度2.
	bool sign; //记录符号。
	char c;
	//va_start(ap, fmt);    //fmt是函数栈底的第二个参数，ap则指向第下一个形参，即第一个可变参数。

	while (*fmt != 0) {
		c = *fmt;
		if (c != '%') {
			str[str_len] = (c);
			str_len++;
		}
		else //c == %,下面解析格式
		{
			fmt++;
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//fmt_len = skip_atoi(&fmt);      //先提取格式长度的数字。如果没有数字，就是0

			//下面看能不能提取数字		
			sign = true;  //符号位默认1；
			if (*fmt == '-') { //遇到负号，提取负号。
				sign = false;
				fmt++;
			}
			fmt_len = 0;
			while (is_digit(*fmt)) {
				fmt_len = fmt_len * 10 + *fmt - '0';
				fmt++;
			}  //数字提取完毕。
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//看能不能再提取一个数字。如果是浮点数的格式，可以用来描述浮点数。
			if (*fmt == '.') { //遇到负号，提取负号。
				fmt++;
				fmt_len2 = 0;
				while (is_digit(*fmt)) {
					fmt_len2 = fmt_len2 * 10 + *fmt - '0';
					fmt++;
				}  //数字提取完毕。
				if (*fmt == 0) return str_len;  //如果格式字符串到了结束
			}

			c = *fmt;                       //提取格式符，下面根据字符的值提取下一个形参。
			if (c == 'c')
			{
				if (fmt_len == 0) {
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 's')
			{
				if (fmt_len == 0) {
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					while (*pc != 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
					}
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					int pc_len = 0;  //记录pc字符串的长度，后面移位用得到。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						pc_len++;
						fmt_len--;
					}     //这里先左对齐。
					if (fmt_len > 0) {
						//需要填充空格，先把字符串移位。再填充fmt_len个空格
						int i;
						for (i = 1; i <= pc_len; i++)
						{
							str[str_len - i + fmt_len] = str[str_len - i];
						}
						for (i = 0; i < fmt_len; i++)
						{
							str[str_len - pc_len + i] = ' ';
						}
						str_len += fmt_len;
					}
				}
				else  //负号，左对齐，右边填充空格
				{
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						fmt_len--;
					}
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == '%')
			{
				if (fmt_len == 0) {
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 'd')
			{
				if (fmt_len == 0) {
					int d = va_arg(ap, int);
					str_len += int_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					int d = va_arg(ap, int);
					int_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					int d = va_arg(ap, int);
					int_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'u')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'f')
			{
				if (fmt_len == 0) {
					//	float d = va_arg(ap, float); //float 会出错，必须要double…………
					float d = (float)va_arg(ap, double);
					str_len += float_to_str_left(d, str + str_len, 18, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					float d = (float)va_arg(ap, double);
					float_to_str(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					float d = (float)va_arg(ap, double);
					float_to_str_left(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
			}
			else if (c == 'x')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 16);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else {
				fmt--; //没有匹配到有效的字符，退出匹配。
			}
		}
		fmt++;
	}
	return str_len;
}

//printf_va_list 的安全版本，这里增加了str的容量str_cap，避免溢出。如果到容量，会强制退出。 如果返回的长度与容量相等，就要怀疑有没有错误。 
//这里有个麻烦的问题:代码不好改，每次字符增加都得加个判断，太多了………… 后面再说。
int printf_va_list_s(char* str,int str_cap, const char* fmt, va_list ap)
{
	//va_list ap;
	int str_len = 0; //转换的字符串的长度
	int fmt_len = 0; //格式的宽度
	int fmt_len2 = 0; //格式的宽度2.
	bool sign; //记录符号。
	char c;
	//va_start(ap, fmt);    //fmt是函数栈底的第二个参数，ap则指向第下一个形参，即第一个可变参数。

	while (*fmt != 0) {
		c = *fmt;
		if (c != '%') {
			str[str_len] = (c);
			str_len++;
		}
		else //c == %,下面解析格式
		{
			fmt++;
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//fmt_len = skip_atoi(&fmt);      //先提取格式长度的数字。如果没有数字，就是0

			//下面看能不能提取数字		
			sign = true;  //符号位默认1；
			if (*fmt == '-') { //遇到负号，提取负号。
				sign = false;
				fmt++;
			}
			fmt_len = 0;
			while (is_digit(*fmt)) {
				fmt_len = fmt_len * 10 + *fmt - '0';
				fmt++;
			}  //数字提取完毕。
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//看能不能再提取一个数字。如果是浮点数的格式，可以用来描述浮点数。
			if (*fmt == '.') { //遇到负号，提取负号。
				fmt++;
				fmt_len2 = 0;
				while (is_digit(*fmt)) {
					fmt_len2 = fmt_len2 * 10 + *fmt - '0';
					fmt++;
				}  //数字提取完毕。
				if (*fmt == 0) return str_len;  //如果格式字符串到了结束
			}

			c = *fmt;                       //提取格式符，下面根据字符的值提取下一个形参。
			if (c == 'c')
			{
				if (fmt_len == 0) {
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 's')
			{
				if (fmt_len == 0) {
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					while (*pc != 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
					}
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					int pc_len = 0;  //记录pc字符串的长度，后面移位用得到。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						pc_len++;
						fmt_len--;
					}     //这里先左对齐。
					if (fmt_len > 0) {
						//需要填充空格，先把字符串移位。再填充fmt_len个空格
						int i;
						for (i = 1; i <= pc_len; i++)
						{
							str[str_len - i + fmt_len] = str[str_len - i];
						}
						for (i = 0; i < fmt_len; i++)
						{
							str[str_len - pc_len + i] = ' ';
						}
						str_len += fmt_len;
					}
				}
				else  //负号，左对齐，右边填充空格
				{
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						fmt_len--;
					}
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == '%')
			{
				if (fmt_len == 0) {
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 'd')
			{
				if (fmt_len == 0) {
					int d = va_arg(ap, int);
					str_len += int_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					int d = va_arg(ap, int);
					int_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					int d = va_arg(ap, int);
					int_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'u')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'f')
			{
				if (fmt_len == 0) {
					//	float d = va_arg(ap, float); //float 会出错，必须要double…………
					float d = (float)va_arg(ap, double);
					str_len += float_to_str_left(d, str + str_len, 18, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					float d = (float)va_arg(ap, double);
					float_to_str(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					float d = (float)va_arg(ap, double);
					float_to_str_left(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
			}
			else if (c == 'x')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 16);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else {
				fmt--; //没有匹配到有效的字符，退出匹配。
			}
		}
		fmt++;
	}
	return str_len;
}

//printf_va_list 是将 va_list 变量的值，按照fmt的格式，放到str 字符串中。
//这里是反过来，将 str字符串的数据，按照fmt的格式，将数据放回变量va_list 中。
int scanf_va_list(char* str,  const char* fmt, va_list ap)
{
	//va_list ap;
	int str_len = 0; //转换的字符串的长度
	int fmt_len = 0; //格式的宽度
	int fmt_len2 = 0; //格式的宽度2.
	bool sign; //记录符号。
	char c;
	//va_start(ap, fmt);    //fmt是函数栈底的第二个参数，ap则指向第下一个形参，即第一个可变参数。

	while (*fmt != 0) {
		c = *fmt;
		if (c != '%') {
			str[str_len] = (c);
			str_len++;
		}
		else //c == %,下面解析格式
		{
			fmt++;
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//fmt_len = skip_atoi(&fmt);      //先提取格式长度的数字。如果没有数字，就是0

			//下面看能不能提取数字		
			sign = true;  //符号位默认1；
			if (*fmt == '-') { //遇到负号，提取负号。
				sign = false;
				fmt++;
			}
			fmt_len = 0;
			while (is_digit(*fmt)) {
				fmt_len = fmt_len * 10 + *fmt - '0';
				fmt++;
			}  //数字提取完毕。
			if (*fmt == 0) return str_len;  //如果格式字符串到了结束

			//看能不能再提取一个数字。如果是浮点数的格式，可以用来描述浮点数。
			if (*fmt == '.') { //遇到负号，提取负号。
				fmt++;
				fmt_len2 = 0;
				while (is_digit(*fmt)) {
					fmt_len2 = fmt_len2 * 10 + *fmt - '0';
					fmt++;
				}  //数字提取完毕。
				if (*fmt == 0) return str_len;  //如果格式字符串到了结束
			}

			c = *fmt;                       //提取格式符，下面根据字符的值提取下一个形参。
			if (c == 'c')
			{
				if (fmt_len == 0) {
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = va_arg(ap, char); //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 's')
			{
				if (fmt_len == 0) {
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					while (*pc != 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
					}
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					char* pc = va_arg(ap, char*); //以指针的形式提取下一个参数。
					int pc_len = 0;  //记录pc字符串的长度，后面移位用得到。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						pc_len++;
						fmt_len--;
					}     //这里先左对齐。
					if (fmt_len > 0) {
						//需要填充空格，先把字符串移位。再填充fmt_len个空格
						int i;
						for (i = 1; i <= pc_len; i++)
						{
							str[str_len - i + fmt_len] = str[str_len - i];
						}
						for (i = 0; i < fmt_len; i++)
						{
							str[str_len - pc_len + i] = ' ';
						}
						str_len += fmt_len;
					}
				}
				else  //负号，左对齐，右边填充空格
				{
					char* pc = va_arg(ap, char* ); //以指针的形式提取下一个参数。
					while (*pc != 0 && fmt_len > 0)  //复制字符串的值。
					{
						str[str_len] = *pc;
						str_len++;
						pc++;
						fmt_len--;
					}
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == '%')
			{
				if (fmt_len == 0) {
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
				}
				else {              //负号，左对齐，右边填充空格
					str[str_len] = '%'; //以字符的形式提取下一个参数。
					str_len++;
					fmt_len--;
					while (fmt_len > 0)
					{
						str[str_len] = ' ';
						str_len++;
						fmt_len--;
					}
				}
			}
			else if (c == 'd')
			{
				if (fmt_len == 0) {
					int d = va_arg(ap, int);
					str_len += int_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					int d = va_arg(ap, int);
					int_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					int d = va_arg(ap, int);
					int_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'u')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 10);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 10);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else if (c == 'f')
			{
				if (fmt_len == 0) {
					//	float d = va_arg(ap, float); //float 会出错，必须要double…………
					float d = (float)va_arg(ap, double );
					str_len += float_to_str_left(d, str + str_len, 18, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					float d = (float)va_arg(ap, double);
					float_to_str(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					float d = (float)va_arg(ap, double);
					float_to_str_left(d, str + str_len, fmt_len, (fmt_len2 == 0) ? 5 : fmt_len2);  //浮点显示5位小数。
					str_len += fmt_len;
				}
			}
			else if (c == 'x')
			{
				if (fmt_len == 0) {
					unsigned int d = va_arg(ap, unsigned int);
					str_len += uint_to_str_left(d, str + str_len, 12, 16);  //整数最多显示12位
				}
				else if (sign == true) //正号，右对齐，左边填充空格。
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
				else  //负号，左对齐，右边填充空格
				{
					unsigned int d = va_arg(ap, unsigned int);
					uint_to_str_left(d, str + str_len, fmt_len, 16);  //整数最多显示12位
					str_len += fmt_len;
				}
			}
			else {
				fmt--; //没有匹配到有效的字符，退出匹配。
			}
		}
		fmt++;
	}
	return str_len;
}



/// <summary>
/// 将格式化字符串fmt转换成普通字符串str，以方便打印。
/// 格式化字符格式为:%+数字+格式化字符(c,s,%,d,u,f,x,X)。
/// 数字表示格式化字符的宽度，如果数字前面有负号，表示左对齐，否则默认右对齐。如果是浮点数，5.2表示浮点数长度是5，保留两位小数。
/// 目前支持的格式化字符如下:
///      %c             字符
///      %s             字符串
///      %%             "%"
///      %d             有符号十进制整数。
///      %u             无符号十进制整数。
///      %f             浮点数(一律保留5位小数)
///      %x             十六进制格式显示整数（无符号整数）。
/// 格式化参数如果不匹配，会打印到栈帧的内容，也可能使程序进入死循环。
/// </summary>
/// <param name="str">转换后的字符串(事先要预留充足的内存，以免数组越界)</param>
/// <param name="fmt">待转换的字符</param>
/// <param name="">格式化参数（可变形参）</param>
/// <returns>转换后字符串长度</returns>
int sprintfs(char* str, const char* fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	return printf_va_list(str, fmt, ap);
}






char printfs_buffer[256];

/// <summary>
/// 格式化打印字符串
/// </summary>
/// <param name="fmt">格式化字符串</param>
/// <param name="">可变参数</param>
void printfs(const char* fmt, ...)
{
	int n;
	va_list ap;
	va_start(ap, fmt);
	n = printf_va_list(printfs_buffer, fmt, ap);
	print_str_(printfs_buffer, n);
}



//这里test print 函数和char str转换函数。
void test_vsprint()
{
	char str[100];
	printfs("\r\n \r\n  vxprintf \r\n \r\n \r\n ");

	{
		print_str_(str, sprintfs(str, "%test print char  \r\n"));

		print_str_(str, sprintfs(str, "char c:%-3c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%-2c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%-1c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%0c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%1c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%2c.\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%3c.\r\n", 'c'));
	}
	{
		print_str_(str, sprintfs(str, "test print char str \r\n"));
		print_str_(str, sprintfs(str, "char str:%-9s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-8s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-7s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-6s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-5s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-4s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-3s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-2s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-1s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%1s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%2s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%3s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%4s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%5s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%6s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%7s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%8s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%9s\r\n", "abcdef"));
	}
	print_str_(str, sprintfs(str, "%test print %% \r\n"));
	{
		print_str_(str, sprintfs(str, "char c:%-3%\r\n"));
		print_str_(str, sprintfs(str, "char c:%-2%\r\n"));
		print_str_(str, sprintfs(str, "char c:%-1%\r\n"));
		print_str_(str, sprintfs(str, "char c:%0%\r\n"));
		print_str_(str, sprintfs(str, "char c:%1%\r\n"));
		print_str_(str, sprintfs(str, "char c:%2%\r\n"));
		print_str_(str, sprintfs(str, "char c:%3%\r\n"));
	}
	print_str_(str, sprintfs(str, "% test print number %%d \r\n"));
	{
		print_str_(str, sprintfs(str, "number:1122334455 %-13d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-10d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-9d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-8d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %13d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %10d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %9d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %8d\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %d\r\n", 1122334455));

		print_str_(str, sprintfs(str, "number:(int)1122334455 %-13d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-10d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-9d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-8d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %13d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %10d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %9d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %8d\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %d\r\n", (int)1122334455));
	}
	print_str_(str, sprintfs(str, "% test print number %%x \r\n"));
	{
		print_str_(str, sprintfs(str, "number:1122334455 %-13x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-10x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-9x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %-7x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %13x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %10x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %9x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %7x\r\n", 1122334455));
		print_str_(str, sprintfs(str, "number:1122334455 %x\r\n", 1122334455));

		print_str_(str, sprintfs(str, "number:(int)1122334455 %-13x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-10x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-9x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %-8x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %13x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %10x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %9x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %8x\r\n", (int)1122334455));
		print_str_(str, sprintfs(str, "number:(int)1122334455 %x\r\n", (int)1122334455));
	}
	{
		float fvar = 11223.344556677f;
		print_str_(str, sprintfs(str, "% test print number %%f \r\n"));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-20f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-15f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-10f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-5f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %20f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %15f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %10f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %5f\r\n", fvar));
		print_str_(str, sprintfs(str, "% test print number,3 decimal %%f \r\n"));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-20.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-15.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-10.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %-5.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %20.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %15.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %10.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:11223.344556677 %5.3f\r\n", fvar));

	}

	////////////////////      下面print 负数

	{
		print_str_(str, sprintfs(str, "%test print char  \r\n"));
		print_str_(str, sprintfs(str, "char c:%-3c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%-2c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%-1c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%0c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%1c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%2c\r\n", 'c'));
		print_str_(str, sprintfs(str, "char c:%3c\r\n", 'c'));
	}
	{
		print_str_(str, sprintfs(str, "test print char str \r\n"));
		print_str_(str, sprintfs(str, "char str:%-9s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-8s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-7s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-6s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-5s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-4s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-3s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-2s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%-1s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%1s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%2s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%3s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%4s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%5s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%6s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%7s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%8s\r\n", "abcdef"));
		print_str_(str, sprintfs(str, "char str:%9s\r\n", "abcdef"));
	}
	{
		print_str_(str, sprintfs(str, "%test print %% \r\n"));
		print_str_(str, sprintfs(str, "char c:%-3%\r\n"));
		print_str_(str, sprintfs(str, "char c:%-2%\r\n"));
		print_str_(str, sprintfs(str, "char c:%-1%\r\n"));
		print_str_(str, sprintfs(str, "char c:%0%\r\n"));
		print_str_(str, sprintfs(str, "char c:%1%\r\n"));
		print_str_(str, sprintfs(str, "char c:%2%\r\n"));
		print_str_(str, sprintfs(str, "char c:%3%\r\n"));
	}

	{
		print_str_(str, sprintfs(str, "% test print number %%d \r\n"));

		print_str_(str, sprintfs(str, "number:-1122334455 %-13d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-10d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-9d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-8d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %13d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %10d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %9d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %8d\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %d\r\n", -1122334455));

		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-13d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-10d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-9d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-8d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %13d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %10d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %9d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %8d\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %d\r\n", (int)-1122334455));
	}
	{
		print_str_(str, sprintfs(str, "% test print number %%x \r\n"));

		print_str_(str, sprintfs(str, "number:-1122334455 %-13x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-10x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-9x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %-8x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %13x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %10x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %9x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %8x\r\n", -1122334455));
		print_str_(str, sprintfs(str, "number:-1122334455 %x\r\n", -1122334455));

		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-13x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-10x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-9x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %-8x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %13x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %10x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %9x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %8x\r\n", (int)-1122334455));
		print_str_(str, sprintfs(str, "number:(int)-1122334455 %x\r\n", (int)-1122334455));
	}
	{
		float fvar = -11223.344556677f;
		print_str_(str, sprintfs(str, "% test print number %%f \r\n"));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-20f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-15f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-10f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-5f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %20f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %15f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %10f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %5f\r\n", fvar));
		print_str_(str, sprintfs(str, "% test print number,3 decimal %%f \r\n"));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-20.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-15.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-10.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %-5.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %20.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %15.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %10.3f\r\n", fvar));
		print_str_(str, sprintfs(str, "number:-11223.344556677 %5.3f\r\n", fvar));
	}

}

void test_print()
{
	test_vsprint();

	printfs("\r\n \r\n test printfs \r\n \r\n \r\n ");
	{
		printfs("%test print char  \r\n");
		printfs("char c:%-3c\r\n", 'c');
		printfs("char c:%-2c\r\n", 'c');
		printfs("char c:%-1c\r\n", 'c');
		printfs("char c:%0c\r\n", 'c');
		printfs("char c:%1c\r\n", 'c');
		printfs("char c:%2c\r\n", 'c');
		printfs("char c:%3c\r\n", 'c');
	}
	{
		printfs("test print char str \r\n");
		printfs("char str:%-9s\r\n", "abcdef");
		printfs("char str:%-8s\r\n", "abcdef");
		printfs("char str:%-7s\r\n", "abcdef");
		printfs("char str:%-6s\r\n", "abcdef");
		printfs("char str:%-5s\r\n", "abcdef");
		printfs("char str:%-4s\r\n", "abcdef");
		printfs("char str:%-3s\r\n", "abcdef");
		printfs("char str:%-2s\r\n", "abcdef");
		printfs("char str:%-1s\r\n", "abcdef");
		printfs("char str:%s\r\n", "abcdef");
		printfs("char str:%1s\r\n", "abcdef");
		printfs("char str:%2s\r\n", "abcdef");
		printfs("char str:%3s\r\n", "abcdef");
		printfs("char str:%4s\r\n", "abcdef");
		printfs("char str:%5s\r\n", "abcdef");
		printfs("char str:%6s\r\n", "abcdef");
		printfs("char str:%7s\r\n", "abcdef");
		printfs("char str:%8s\r\n", "abcdef");
		printfs("char str:%9s\r\n", "abcdef");
	}
	printfs("%test print %% \r\n");
	{
		printfs("char c:%-3%\r\n");
		printfs("char c:%-2%\r\n");
		printfs("char c:%-1%\r\n");
		printfs("char c:%0%\r\n");
		printfs("char c:%1%\r\n");
		printfs("char c:%2%\r\n");
		printfs("char c:%3%\r\n");
	}
	printfs("% test print number %%d \r\n");
	{
		printfs("number:1122334455 %-13d\r\n", 1122334455);
		printfs("number:1122334455 %-10d\r\n", 1122334455);
		printfs("number:1122334455 %-9d\r\n", 1122334455);
		printfs("number:1122334455 %-8d\r\n", 1122334455);
		printfs("number:1122334455 %13d\r\n", 1122334455);
		printfs("number:1122334455 %10d\r\n", 1122334455);
		printfs("number:1122334455 %9d\r\n", 1122334455);
		printfs("number:1122334455 %8d\r\n", 1122334455);
		printfs("number:1122334455 %d\r\n", 1122334455);

		printfs("number:(int)1122334455 %-13d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-10d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-9d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-8d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %13d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %10d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %9d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %8d\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %d\r\n", (int)1122334455);
	}
	printfs("% test print number %%x \r\n");
	{
		printfs("number:1122334455 %-13x\r\n", 1122334455);
		printfs("number:1122334455 %-10x\r\n", 1122334455);
		printfs("number:1122334455 %-9x\r\n", 1122334455);
		printfs("number:1122334455 %-7x\r\n", 1122334455);
		printfs("number:1122334455 %13x\r\n", 1122334455);
		printfs("number:1122334455 %10x\r\n", 1122334455);
		printfs("number:1122334455 %9x\r\n", 1122334455);
		printfs("number:1122334455 %7x\r\n", 1122334455);
		printfs("number:1122334455 %x\r\n", 1122334455);

		printfs("number:(int)1122334455 %-13x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-10x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-9x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %-8x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %13x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %10x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %9x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %8x\r\n", (int)1122334455);
		printfs("number:(int)1122334455 %x\r\n", (int)1122334455);
	}
	{
		float fvar = 11223.344556677f;
		printfs("% test print number %%f \r\n");
		printfs("number:11223.344556677 %-20f\r\n", fvar);
		printfs("number:11223.344556677 %-15f\r\n", fvar);
		printfs("number:11223.344556677 %-10f\r\n", fvar);
		printfs("number:11223.344556677 %-5f\r\n", fvar);
		printfs("number:11223.344556677 %f\r\n", fvar);
		printfs("number:11223.344556677 %20f\r\n", fvar);
		printfs("number:11223.344556677 %15f\r\n", fvar);
		printfs("number:11223.344556677 %10f\r\n", fvar);
		printfs("number:11223.344556677 %5f\r\n", fvar);
		printfs("% test print number,3 decimal %%f \r\n");
		printfs("number:11223.344556677 %-20.3f\r\n", fvar);
		printfs("number:11223.344556677 %-15.3f\r\n", fvar);
		printfs("number:11223.344556677 %-10.3f\r\n", fvar);
		printfs("number:11223.344556677 %-5.3f\r\n", fvar);
		printfs("number:11223.344556677 %.3f\r\n", fvar);
		printfs("number:11223.344556677 %20.3f\r\n", fvar);
		printfs("number:11223.344556677 %15.3f\r\n", fvar);
		printfs("number:11223.344556677 %10.3f\r\n", fvar);
		printfs("number:11223.344556677 %5.3f\r\n", fvar);

	}

	////////////////////      下面print 负数

	{
		printfs("%test print char  \r\n");
		printfs("char c:%-3c\r\n", 'c');
		printfs("char c:%-2c\r\n", 'c');
		printfs("char c:%-1c\r\n", 'c');
		printfs("char c:%0c\r\n", 'c');
		printfs("char c:%1c\r\n", 'c');
		printfs("char c:%2c\r\n", 'c');
		printfs("char c:%3c\r\n", 'c');
	}
	{
		printfs("test print char str \r\n");
		printfs("char str:%-9s\r\n", "abcdef");
		printfs("char str:%-8s\r\n", "abcdef");
		printfs("char str:%-7s\r\n", "abcdef");
		printfs("char str:%-6s\r\n", "abcdef");
		printfs("char str:%-5s\r\n", "abcdef");
		printfs("char str:%-4s\r\n", "abcdef");
		printfs("char str:%-3s\r\n", "abcdef");
		printfs("char str:%-2s\r\n", "abcdef");
		printfs("char str:%-1s\r\n", "abcdef");
		printfs("char str:%s\r\n", "abcdef");
		printfs("char str:%1s\r\n", "abcdef");
		printfs("char str:%2s\r\n", "abcdef");
		printfs("char str:%3s\r\n", "abcdef");
		printfs("char str:%4s\r\n", "abcdef");
		printfs("char str:%5s\r\n", "abcdef");
		printfs("char str:%6s\r\n", "abcdef");
		printfs("char str:%7s\r\n", "abcdef");
		printfs("char str:%8s\r\n", "abcdef");
		printfs("char str:%9s\r\n", "abcdef");
	}
	{
		printfs("%test print %% \r\n");
		printfs("char c:%-3%\r\n");
		printfs("char c:%-2%\r\n");
		printfs("char c:%-1%\r\n");
		printfs("char c:%0%\r\n");
		printfs("char c:%1%\r\n");
		printfs("char c:%2%\r\n");
		printfs("char c:%3%\r\n");
	}

	{
		printfs("% test print number %%d \r\n");

		printfs("number:-1122334455 %-13d\r\n", -1122334455);
		printfs("number:-1122334455 %-10d\r\n", -1122334455);
		printfs("number:-1122334455 %-9d\r\n", -1122334455);
		printfs("number:-1122334455 %-8d\r\n", -1122334455);
		printfs("number:-1122334455 %13d\r\n", -1122334455);
		printfs("number:-1122334455 %10d\r\n", -1122334455);
		printfs("number:-1122334455 %9d\r\n", -1122334455);
		printfs("number:-1122334455 %8d\r\n", -1122334455);
		printfs("number:-1122334455 %d\r\n", -1122334455);

		printfs("number:(int)-1122334455 %-13d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-10d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-9d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-8d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %13d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %10d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %9d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %8d\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %d\r\n", (int)-1122334455);
	}
	{
		printfs("% test print number %%x \r\n");

		printfs("number:-1122334455 %-13x\r\n", -1122334455);
		printfs("number:-1122334455 %-10x\r\n", -1122334455);
		printfs("number:-1122334455 %-9x\r\n", -1122334455);
		printfs("number:-1122334455 %-8x\r\n", -1122334455);
		printfs("number:-1122334455 %13x\r\n", -1122334455);
		printfs("number:-1122334455 %10x\r\n", -1122334455);
		printfs("number:-1122334455 %9x\r\n", -1122334455);
		printfs("number:-1122334455 %8x\r\n", -1122334455);
		printfs("number:-1122334455 %x\r\n", -1122334455);

		printfs("number:(int)-1122334455 %-13x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-10x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-9x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %-8x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %13x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %10x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %9x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %8x\r\n", (int)-1122334455);
		printfs("number:(int)-1122334455 %x\r\n", (int)-1122334455);
	}
	{
		float fvar = -11223.344556677f;
		printfs("% test print number %%f \r\n");
		printfs("number:-11223.344556677 %-20f\r\n", fvar);
		printfs("number:-11223.344556677 %-15f\r\n", fvar);
		printfs("number:-11223.344556677 %-10f\r\n", fvar);
		printfs("number:-11223.344556677 %-5f\r\n", fvar);
		printfs("number:-11223.344556677 %f\r\n", fvar);
		printfs("number:-11223.344556677 %20f\r\n", fvar);
		printfs("number:-11223.344556677 %15f\r\n", fvar);
		printfs("number:-11223.344556677 %10f\r\n", fvar);
		printfs("number:-11223.344556677 %5f\r\n", fvar);
		printfs("% test print number,3 decimal %%f \r\n");
		printfs("number:-11223.344556677 %-20.3f\r\n", fvar);
		printfs("number:-11223.344556677 %-15.3f\r\n", fvar);
		printfs("number:-11223.344556677 %-10.3f\r\n", fvar);
		printfs("number:-11223.344556677 %-5.3f\r\n", fvar);
		printfs("number:-11223.344556677 %.3f\r\n", fvar);
		printfs("number:-11223.344556677 %20.3f\r\n", fvar);
		printfs("number:-11223.344556677 %15.3f\r\n", fvar);
		printfs("number:-11223.344556677 %10.3f\r\n", fvar);
		printfs("number:-11223.344556677 %5.3f\r\n", fvar);
	}

}

void test_printfloat()
{
	float f = -1;

	/*
	f = -2; for (i = 0; i < 20; i++) {printfs("\r\n  f = %-6.3f ", f); f += 0.001;}
	f = -1; for (i = 0; i < 20; i++) { printfs("\r\n  f = %-6.3f ", f); f += 0.01; }
	f = 0; for (i = 0; i < 20; i++) { printfs("\r\n  f = %-6.3f ", f); f += 0.001; }
	f = 1; for (i = 0; i < 20; i++) { printfs("\r\n  f = %-6.3f ", f); f += 0.001; }
	f = 10; for (i = 0; i < 20; i++) { printfs("\r\n  f = %-6.3f ", f); f += 0.01; }
*/

	//printfs("%-8.3f,", -19.09);
	//printfs("%-8.3f,", -19.089);
	//printfs("%-8.3f,", -19.087);

//	return;

	f = -20; 
	char str[20];

	sprintfs(str, "%-8.3f,", f);
	float f2;

	for (int i = 0; i < 40000; i++) {
		//for (int j = 0; j < 10; j++) 
		{

			sprintfs(str, "%-8.3f,", f);
			str_to_float(str, &f2);

			if (ABS(f2 - f) >= 0.0005)
				printfs("%-8.6f  ,  %-8.6f, \r\n", f, f2);

			f += 0.001f;
		}
	//	printfs("\r\n");
	}
		printfs("finish");


}






